Compound message for block motion estimation

ABSTRACT

An embodiment of a motion estimator apparatus may include technology to receive a compound message, and perform rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message. Other embodiments are disclosed and claimed.

TECHNICAL FIELD

Embodiments generally relate to video systems. More particularly, embodiments relate to a compound message for block motion estimation.

BACKGROUND

When video information is transmitted, the video information may be encoded and/or compressed to reduce the transmission bandwidth. Many video encoding/compression techniques may include motion estimation. Video information may include a sequence of images processed as a series of frames. Motion estimation techniques may utilize redundancy between frames to compress the video information.

BRIEF DESCRIPTION OF THE DRAWINGS

The various advantages of the embodiments will become apparent to one skilled in the art by reading the following specification and appended claims, and by referencing the following drawings, in which:

FIG. 1 is a block diagram of an example of an electronic processing system according to an embodiment;

FIG. 2 is a block diagram of an example of a graphics apparatus according to an embodiment;

FIG. 3 is a block diagram of an example of a motion estimation system according to an embodiment;

FIG. 4 is a block diagram of another example of a motion estimation apparatus according to an embodiment;

FIGS. 5A to 5B are flowcharts of another example of a method of estimating motion according to an embodiment;

FIG. 6 is a block diagram of an example of modular motion estimator apparatus according to an embodiment;

FIGS. 7A and 7B are illustrative diagrams of an example of a coding unit selection process flow according to an embodiment;

FIG. 8 is a flowchart of an example of a process flow for coding unit selection according to an embodiment;

FIG. 9 is a block diagram of an example of a system having a navigation controller according to an embodiment; and

FIG. 10 is a block diagram of an example of a system having a small form factor according to an embodiment.

DESCRIPTION OF EMBODIMENTS

Some embodiments may provide an improved architecture and techniques for performing motion estimation of media that contain multiple image frames, particularly for tree-based video. Some embodiments may particularly apply to motion estimation for video encoding, video conferencing, image stabilization, and frame rate conversion, among others. As detailed below an embodiment of a modular motion estimation (MME) engine is described that may contain modular hardware components to perform different techniques for a motion estimation of image frames such as video frames. In some embodiments, the modularity of the motion estimation hardware may provide a flexible and diverse set of techniques that may be applied to a wide variety of workloads beyond video encoding.

In some embodiments, the modular motion estimation engine may be harnessed to process an image frame via multiple parallel execution pipelines. In some embodiments, the modular motion estimation engine may alternatively, or additionally, provide a configurable architecture in which novel execution pipelines may be generated and novel operations may be performed during the motion estimation process. Such configurable architecture may allow different combinations of hardware-based motion estimation circuits to be harnessed to synthesize a given execution pipeline or combination of execution pipelines. Some embodiments may entail use of an advanced skip check engine having forward transform capabilities, hardware assisted multi-reference search support, hardware accelerated chroma intra frame prediction, hardware accelerated chroma inter frame prediction, use of weighted sum of absolute differences (SAD) procedure for true motion estimation, support for at least four predictors, support for intra directional features, and/or support for intra streamout. Some embodiments may also provide flexibility to adapt motion estimation to different workloads including image stabilization, frame rate conversion, gesture tracking, and other tasks.

Turning now to FIG. 1, an embodiment of an electronic processing system 10 may include an example architecture for performing motion estimation of image frames. A device 11 may receive media content 12 from a source 13 for processing. The media content 12 may be video in various embodiments, which may be processed as a series of video frames to perform motion estimation to provide processed media content 14. The device 11 may output the processed media content 14 to a target 15, which may be an external device, a digital display, or other device to consume the processed media content 14. In some embodiments of video encoding, the processed media content 14 may be encoded video.

The device 11 may include a general purpose processor (e.g., a central processor unit (CPU)) 16, a graphics processor (e.g., a graphics processor unit (GPU)) 17, and memory 18. During motion estimation, the memory 18, which may be a buffer, may receive multiple image frames of a media such as video to be processed. In some embodiments, these components and others may be embodied in a platform such as a mobile phone, smartphone, tablet computer, laptop computer or other mobile device, desktop computer, video game device, television, or hybrid communications/computing device. In some embodiments, the device 11 may be a system-on-chip (SoC) in which the components shown therein are embodied in a single semiconductor die. The embodiments are not limited in this context.

The device 11 may additionally include a modular motion estimation engine 19 (e.g., features of which may be described in more detail herein). The modular motion estimation engine 19 may process the media content 12 received by device 11 to accelerate motion estimation in a manner that is tailored to the media content 12 and/or processing requirements. For example, some embodiments may be improved or optimized for a tree-based video standard such as VP9 format (e.g., VP9 Bitstream & Decoding Process Specification, Version 0.6, published Mar. 31, 2016), high-efficiency video coding (HEVC) format (e.g., Recommendation ITU-T H.265 v4, published December 2016), multi-view HEVC format, 3D-HEVC format, etc.

For example, the modular motion estimation engine 19 may include hybrid atomic and compound block motion estimation and mode decision technology. Some embodiments may include a compound message which may be configured to make multiple rate distortion estimation (RDE) calls in a single message which may be pipelined to achieve higher performance, reduce memory usage, and shrink the kernel size. Some embodiments may additionally include a specialized call for 8×8 coding units (CUs) which allows the 8×8 CUs to be processed like a 16×16 CU, which significantly improves performance for the 8×8 CUs and reduces kernel size. Some embodiments may advantageously provide a more flexible approach for motion estimation in comparison to conventional hardware-managed motion estimation that employs rigid pipelines. Some embodiments may advantageously provide improved or optimized performance for tree-based video as compared to other modular approaches for other video standards such as advanced video coding (AVC) formats.

The modular motion estimation engine 19 may include various hardware elements, software elements, or a combination of both. Examples of hardware elements may include devices, components, processors, microprocessors, circuits, circuit elements (e.g., transistors, resistors, capacitors, inductors, and so forth), integrated circuits, application specific integrated circuits (ASIC), programmable logic devices (PLD), digital signal processors (DSP), field programmable gate array (FPGA), memory units, logic gates, registers, semiconductor device, chips, microchips, chip sets, and so forth. Examples of software elements may include software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application program interfaces (API), instruction sets, computing code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. Determining whether an embodiment is implemented using hardware elements and/or software elements may vary in accordance with any number of factors, such as desired computational rate, power levels, heat tolerances, processing cycle budget, input data rates, output data rates, memory resources, data bus speeds and other design or performance constraints, as desired for a given implementation.

Turning now to FIG. 2, an embodiment of a graphics apparatus 40 may include a graphics processor 21, memory 22 communicatively coupled to the graphics processor 21, and a modular motion estimator 23 communicatively coupled to the graphics processor 21 and the memory 22. For example, the modular motion estimator 23 may be readily substituted for the modular motion estimation engine 19 (FIG. 1). The modular motion estimator 23 may include motion estimation circuitry 24, which may be located in the graphics processor 21. The modular motion estimator 23 may further include a motion estimation kernel 25 communicatively coupled to the motion estimation circuitry 24, which may act in concert with the motion estimation circuitry 24 to perform motion estimation. For example, the motion estimation circuitry 24 and the motion estimation kernel may include logic to provide the hybrid atomic and compound block motion estimation and mode decision technology. In some embodiments, the logic may be configured to handle a compound message which may include multiple RDE calls in a single message. The logic may be pipelined to achieve higher performance, reduce memory usage, and shrink the kernel size. In some embodiments, the logic may be further configured to handle a specialized call for 8×8 CUs which allows the 8×8 CUs to be processed like a 16×16 CU, which significantly improves performance for the 8×8 CUs and reduces kernel size. In some embodiments of video encoding, the apparatus 40 may include additional circuitry such as an encoding engine that may operate on input media content 26 in conjunction with the modular motion estimator 23 to output processed media content 27 as encoded video.

Embodiments of each of the above graphics processor 21, memory 22, modular motion estimator 23, and other system components may be implemented in hardware, software, or any suitable combination thereof. For example, hardware implementations may include configurable logic such as, for example, programmable logic arrays (PLAs), field programmable gate arrays (FPGAs), complex programmable logic devices (CPLDs), or fixed-functionality logic hardware using circuit technology such as, for example, application specific integrated circuit (ASIC), complementary metal oxide semiconductor (CMOS) or transistor-transistor logic (TTL) technology, or any combination thereof.

Alternatively, or additionally, all or portions of these components may be implemented in one or more modules as a set of logic instructions stored in a machine- or computer-readable storage medium such as random access memory (RAM), read only memory (ROM), programmable ROM (PROM), firmware, flash memory, etc., to be executed by a processor or computing device. For example, computer program code to carry out the operations of the components may be written in any combination of one or more operating system (OS) applicable/appropriate programming languages, including an object-oriented programming language such as PYTHON, PERL, JAVA, SMALLTALK, C++, C# or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. For example, the memory 22, the motion estimation kernel 25, persistent storage media, or other device memory may store a set of instructions which when executed by the graphics processor 21 and/or motion estimation circuitry 24 cause the graphics apparatus 40 to implement one or more components, features, or aspects of the apparatus 40 (e.g., the logic, the compound message technology, etc.).

Turning now to FIG. 3, an embodiment of a motion estimation system 30 may include a processor 31, memory 32 communicatively coupled to the processor 31, and logic 33 communicatively coupled to the processor 31 to receive a compound message, and perform RDE and check refinement (CR) for two or more CU descriptions for a source block based on the received compound message. In some embodiments, the logic 33 may be further configured to perform RDE and CR for an inter candidate CU, a skip/merge candidate CU, and an intra candidate CU based on the received compound message. The logic 33 may also be configured to perform RDE and CR for the two or more CU descriptions in a pipelined manner (e.g., in two or more assembly line stages, some of which may be worked on at the same time). For example, the logic 33 may be configured to store intermediate results (e.g., including reconstructed pixels) for each of the two or more CU descriptions for use while the RDE and CR is performed. In some embodiments, the logic 33 may be further configured to perform RDE and CR for two or more levels of coding CUs with a same logic circuit (e.g., a N×N CU, quad N/2×N/2 CUs, and so on). The logic 33 may also be configured to receive an atomic message (e.g., a non-compound message), and perform RDE and CR for a single inter candidate CU, skip/merge candidate CU, or intra candidate CU based on the received atomic message. In some embodiments, the logic 33 may be located in, or co-located with, various components, including the processor 31 (e.g., on a same die).

Embodiments of each of the above processor 31, memory 32, logic 33, and other system components may be implemented in hardware, software, or any suitable combination thereof. For example, hardware implementations may include configurable logic such as, for example, programmable logic arrays (PLAs), field programmable gate arrays (FPGAs), complex programmable logic devices (CPLDs), or fixed-functionality logic hardware using circuit technology such as, for example, application specific integrated circuit (ASIC), complementary metal oxide semiconductor (CMOS) or transistor-transistor logic (TTL) technology, or any combination thereof. Embodiments of the processor 31 may include a general purpose processor, a special purpose processor, a central processor unit (CPU), a controller, a micro-controller, etc.

Alternatively, or additionally, all or portions of these components may be implemented in one or more modules as a set of logic instructions stored in a machine- or computer-readable storage medium such as random access memory (RAM), read only memory (ROM), programmable ROM (PROM), firmware, flash memory, etc., to be executed by a processor or computing device. For example, computer program code to carry out the operations of the components may be written in any combination of one or more operating system (OS) applicable/appropriate programming languages, including an object-oriented programming language such as PYTHON, PERL, JAVA, SMALLTALK, C++, C# or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. For example, the memory 32, persistent storage media, or other system memory may store a set of instructions which when executed by the processor 31 cause the system 10 to implement one or more components, features, or aspects of the system 10 (e.g., the logic 33, receiving the compound message, performing RDE and CR for the two or more CU descriptions for a source block based on the received compound message, etc.).

Turning now to FIG. 4, an embodiment of a motion estimation apparatus 40 for use with a video encoder may include one or more substrates 41, and logic 42 coupled to the one or more substrates 41, wherein the logic 42 is at least partly implemented in one or more of configurable logic and fixed-functionality hardware logic. The logic 42 coupled to the one or more substrates 41 may be configured to receive a compound message, and perform RDE and CR for two or more CU descriptions for a source block based on the received compound message. In some embodiments, the logic 42 may be further configured to perform RDE and CR for an inter candidate CU, a skip/merge candidate CU, and an intra candidate CU based on the received compound message. The logic 42 may also be configured to perform RDE and CR for the two or more CU descriptions in a pipelined manner. For example, the logic 42 may be configured to store intermediate results for each of the two or more CU descriptions for use while the RDE and CR is performed. In some embodiments, the logic 42 may be further configured to perform RDE and CR for two or more levels of coding CUs with a same logic circuit (e.g., a N×N CU, quad N/2×N/2 CUs, and so on). The logic 42 may also be configured to receive an atomic message, and perform RDE and CR for a single inter candidate CU, skip/merge candidate CU, or intra candidate CU based on the received atomic message. In some embodiments, the logic 42 coupled to the one or more substrates 41 may include transistor channel regions that are positioned within the one or more substrates 41.

Embodiments of logic 42, and other components of the apparatus 40, may be implemented in hardware, software, or any combination thereof including at least a partial implementation in hardware. For example, hardware implementations may include configurable logic such as, for example, PLAs, FPGAs, CPLDs, or fixed-functionality logic hardware using circuit technology such as, for example, ASIC, CMOS, or TTL technology, or any combination thereof. Additionally, portions of these components may be implemented in one or more modules as a set of logic instructions stored in a machine- or computer-readable storage medium such as RAM, ROM, PROM, firmware, flash memory, etc., to be executed by a processor or computing device. For example, computer program code to carry out the operations of the components may be written in any combination of one or more OS applicable/appropriate programming languages, including an object-oriented programming language such as PYTHON, PERL, JAVA, SMALLTALK, C++, C# or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages.

The apparatus 40 may implement one or more aspects of the method 50 (FIGS. 5A to 5B), or any of the embodiments discussed herein. In some embodiments, the illustrated apparatus 40 may include the one or more substrates 41 (e.g., silicon, sapphire, gallium arsenide) and the logic 42 (e.g., transistor array and other integrated circuit/IC components) coupled to the substrate(s) 41. The logic 42 may be implemented at least partly in configurable logic or fixed-functionality logic hardware. In one example, the logic 42 may include transistor channel regions that are positioned (e.g., embedded) within the substrate(s) 41. Thus, the interface between the logic 42 and the substrate(s) 41 may not be an abrupt junction. The logic 42 may also be considered to include an epitaxial layer that is grown on an initial wafer of the substrate(s) 41.

Turning now to FIGS. 5A to 5B, an embodiment of a method 50 of estimating motion may include receiving a compound message at block 51, and performing RDE and CR for two or more CU descriptions for a source block based on the received compound message at block 52. Some embodiments of the method 50 may include performing RDE and CR for an inter candidate CU, a skip/merge candidate CU, and an intra candidate CU based on the received compound message at block 53. For example, the method 50 may include performing RDE and CR for the two or more CU descriptions in a pipelined manner at block 54, and storing intermediate results for each of the two or more CU descriptions for use while the RDE and CR is performed at block 55. Some embodiments of the method 50 may also include performing RDE and CR for two or more levels of coding CUs with a same logic circuit at block 56 (e.g., a N×N CU, quad N/2×N/2 CUs, and so on). Some embodiments of the method 50 may further include receiving an atomic message at block 57, and performing RDE and CR for a single inter candidate CU, skip/merge candidate CU, or intra candidate CU based on the received atomic message at block 58.

Embodiments of the method 50 may be implemented in a system, apparatus, computer, device, etc., for example, such as those described herein. More particularly, hardware implementations of the method 50 may include configurable logic such as, for example, PLAs, FPGAs, CPLDs, or in fixed-functionality logic hardware using circuit technology such as, for example, ASIC, CMOS, or TTL technology, or any combination thereof. Alternatively, or additionally, the method 50 may be implemented in one or more modules as a set of logic instructions stored in a machine- or computer-readable storage medium such as RAM, ROM, PROM, firmware, flash memory, etc., to be executed by a processor or computing device. For example, computer program code to carry out the operations of the components may be written in any combination of one or more OS applicable/appropriate programming languages, including an object-oriented programming language such as PYTHON, PERL, JAVA, SMALLTALK, C++, C# or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages.

For example, the method 50 may be implemented on a computer readable medium as described in connection with Examples 20 to 25 below. Embodiments or portions of the method 50 may be implemented in firmware, applications (e.g., through an application programming interface (API)), or driver software running on an operating system (OS). Additionally, logic instructions might include assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, state-setting data, configuration data for integrated circuitry, state information that personalizes electronic circuitry and/or other structural components that are native to hardware (e.g., host processor, central processing unit/CPU, microcontroller, etc.).

Some embodiments may advantageously provide modular motion estimation and mode decision for tree-based video formats, further including hybrid atomic and compound block motion estimation and mode decision technology. For example, some embodiments may provide a set of features for advanced video encoding in hardware, optimized for a HEVC and/or a VP9 class of video formats. There are numerous issues that must be addressed in hardware encoders such as cost, complexity, flexibility and performance which must be balanced with achieving high video fidelity with the lowest bitrate encoded bitstream. Some embodiments may advantageously provide high quality together with substantial software programmability.

Other systems may re-purpose an AVC-based encoder to encode HEVC and/or VP9. However, compression and performance may both be sacrificed when using an AVC-based video motion estimation because the encoder may not be well-suited for coding, partition, and/or transform unit trees. Some embodiments may provide a video motion estimator (VME) with a modular motion estimation engine inside of the graphics processor/GPU optimized for tree-based video. In some embodiments, the VME may be based on atomic messages that do specific checks or searches within a larger encoder technique network, allowing various networks to be created which can be tailored for performance or quality.

Some embodiments may include a hardware engine that delivers both high accuracy and high-performance computations as a co-processor to deliver high quality while still allowing for flexible software implementations. As opposed to a fixed function encoder that has its encoder flow defined in hardware, some embodiments of a modular motion estimation engine may be at the core of numerous different encoder mode decision networks. As opposed to a pure software encoder that doesn't have any co-processor to offload critical functions such as motion estimation or rate distortion optimization computations, some embodiments may include a hardware co-processor/accelerator to offload computations. Advantageously, some embodiments may provide the performance of a fixed function encoder with the programmability of a software encoder. For a non-HEVC VME workload, some embodiments of a VME may be backwards compatible with one or more non-HEVC formats at the binary level for input and output, with performance largely unaffected.

Some differences between HEVC and AVC may include different partition/CU sizes (e.g., which may exceed 16×16 in HEVC), the transform unit decision (e.g., for HEVC the VME may need to include a forward transform in partitioning logic), and intra may have considerably more prediction modes in HEVC as compared to AVC (e.g., 35 vs. 9). Advantageously, some embodiments may be configurable to manage these differences in software/hardware to support AVC while providing improved performance for HEVC (e.g., or other tree-based video formats). For example, some embodiments may be programmable to optimize for power, performance, and quality for tree-based video formats.

Turning now to FIG. 6, an embodiment of a modular motion estimator 80 may be logically or physically organized as one or more modules. For example, the modular motion estimator 80 may include an integer motion estimation (IME) module 81, a hierarchical partition message (HPM) module 82, a skip intra check (SIC) module 83, a fractional motion estimation (FME) module 84, a bi-directional motion estimation (BME) module 85, a skip refinement message (SRM) module 86, a residual prediction message (RPM) module 87, an intra+RDE module 88, a skip+RDE module 89, and an inter+RDE module 90. The modular motion estimator 80 further includes a compound message module (CMM) 91. The IME 81 may include an increased source size and reference window storage. The IME 81 may also include increased shape sizes in the record and may expand streamout (e.g., 49 shapes). The HPM 82 may be configured to process a partition message to offload the IME 81 from the partitioning duties to support coding unit (CU), prediction unit (PU), and/or transform unit (TU) decisions for the tree-based video format. The SIC 83 may include an increased source size and reference window storage. The SIC 83 may also support up to four (4) predictors in one call derived internally by the VME, or four predictors explicitly provided by the kernel. The SIC 83 may also support intra directional filters, and may also support intra streamout. The FME 84 may include an increased source size and reference window storage. The FME 84 may also be based on a half pel (Hpel) and/or a quarter pel (Qpel) distortion mesh. The BME 85 may include an increased source size and reference window storage. The SRM 86 may help to offload the SIC 83 for skip replacement of CU's as a final stage of a mode decision. The RPM 87 may help to replace forward transform by returning a residual to the kernel for additional processing.

In some embodiments of the modular motion estimator 80, the skip+RDE 89 may perform one or more of merge and skip residual error analysis on a first CU packet and determine a best merge candidate CU and a first rate distortion optimization cost based on the analysis. The IME 81 may perform integer motion estimation on second CU packet and determine a best partition candidate CU and a second rate distortion optimization cost based on the partition candidates. The inter+RDE 90 may perform fractional and bidirectional motion estimation residual error analysis on a third CU packet and determine a best inter candidate CU and a third rate distortion optimization cost based on the analysis. The intra+RDE 88 may perform an intra mode search residual error analysis on a fourth CU packet and determine a best intra candidate CU and a fourth rate distortion optimization cost based on the analysis. For example, a kernel/control logic may control a process flow to construct the CU packets based on the best candidate CU information received from the modules.

Embodiments of the CMM 91 include technology to handle a compound message which may include multiple RDE calls in a single message. The CMM 91 may pipeline the handling of the compound messages to achieve higher performance, reduce memory usage, and shrink the kernel size. In some embodiments, the CMM 91 may be further configured to handle a specialized call for 8×8 CUs which allows the 8×8 CUs to be processed like a 16×16 CU, which significantly improves performance for the 8×8 CUs and reduces kernel size. In some embodiments, the CMM 91 may be configured to perform RDE and CR for two or more CU descriptions for a source block based on the received compound message (e.g., by making appropriate calls to the intra+RDE 88, skip+RDE 89, and inter+RDE 90 modules, which may be pipelined). For example, the modular motion estimator 80 may include configurable buffers and the CMM 91 may be configured to store intermediate results (e.g., including reconstructed pixels) for each of the two or more CU descriptions for a source block in the configurable buffers. The modular motion estimator 80 may also be configured to receive an atomic message, and perform RDE and CR for a single inter candidate CU, skip/merge candidate CU, or intra candidate CU based on the received atomic message (e.g., providing a hybrid of fine-grained MME and coarse-grained MME).

Embodiments of the IME 81, the HPM 82, the SIC 83, FME 84, BME 85, SRM 86, RPM 87, intra+RDE 88, skip+RDE 89, inter+RDE 90, CMM 91, and other components of the modular motion estimator 80, may be implemented in hardware, software, or any combination thereof. For example, hardware implementations may include configurable logic such as, for example, PLAs, FPGAs, CPLDs, or fixed-functionality logic hardware using circuit technology such as, for example, ASIC, CMOS, or TTL technology, or any combination thereof. Additionally, portions of these components may be implemented in one or more modules as a set of logic instructions stored in a machine- or computer-readable storage medium such as RAM, ROM, PROM, firmware, flash memory, etc., to be executed by a processor or computing device. For example, computer program code to carry out the operations of the components may be written in any combination of one or more OS applicable/appropriate programming languages, including an object-oriented programming language such as PYTHON, PERL, JAVA, SMALLTALK, C++, C# or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages.

IME Examples

Some embodiments may decouple the CUs and PUs and provide an increased maximum size and division for a given CU. In some embodiments, inter and intra frames may be mixed together within the block type along with a number of ways to sub-divide blocks into different shape sizes. For example, the largest CU (LCU) for H.265 v4 may be as large as 64×64 pixels (e.g., 16 times more pixels than AVC's 16×16 macroblock). The LCU may be divided into quarter elements through a process of quad-tree division. The encoder may choose to subdivide the LCU into four 32×32 blocks. Each of these 32×32 CUs may be further split into smaller CUs (e.g., four 16×16 CUs) or may maintain their current size (one 32×32 CU). The process may continue to subdivide into smaller CUs (e.g., four 8×8 CUs) or may main their current size (one 16×16 CU). Some embodiments may specify a maximum depth at which an LCU can be divided (e.g., up to 4 times). The encoder may be configured to honor the specified depth.

An embodiment of a HEVC-based VME may support a 64×64 reference window with a 32×32 search range (e.g., a 32×32 source size) for a total of 1024 search points (e.g., 64 search units). Some embodiments may increase the reference window storage to accommodate a larger source size maintaining a reasonable search range per call. Some embodiments may refer to the larger reference window as a big window mode. Some embodiments may reduce the number of candidates to a few to reduce complexity while still supporting performance optimized reference window choices. For example, some embodiments of a HEVC-based VME may also support a 48×48 reference window with a 16×16 search range for a total of 256 search points (e.g., 16 search units), and also a 48×40 reference window with a 16×8 search range (e.g., 8 search units). These smaller window modes may load a lower number of cachelines as compared to the big window mode.

In some embodiments, if a smaller source size (e.g., a 16×16 source size) is selected, the sizes allowed may likewise be restricted such that the number of search units does not exceed a maximum number (e.g., 64) that is supported by the VME. The big window mode may support search path controls and/or adaptive searching. In some embodiments, for a 32×32 source size adaptive search may key off of 16×16 shape distortions instead of 8×8 shape distortions. Some embodiments of a HEVC-based VME may include many more shapes because of the CU and PU combinations supported. The IME may only support a subset of the shapes based on simulation results for the most beneficial candidates. For example, the IME may support 49 shapes for a 32×32 source size including one 32×32, two 32×16, two 16×32, four 16×16, 32×8_T, 32×8_B, 32×24_T, 32×24_B, 8×32_L, 8×32_R, 24×32_L, 24×32_R, eight 16×8, eight 8×16, and sixteen 8×8, where T corresponds to top, B corresponds to bottom, L corresponds to left, and R corresponds to right. Other standards may have similar shape structures with different nomenclature. In some embodiments, shapes below 8×8 (e.g., 32 8×4, 32 4×8, and 64 4×4) may not be supported for lack of benefit to HD and above content resolutions and because of the large number of such shapes (e.g., another 128 shapes). Additionally, some embodiments may not support the asymmetrical candidates for the 16×16 level (e.g., 16×4, 4×16, 12×16, 16×12) because the benefit may be reduced as compared to the 32×32 level versions and the large number of such shapes (e.g., another 64 shapes).

HPM Examples

In some embodiments, each choice to split a CU into quarter elements may be represented by one (1) bit which indicates to split or to not split. If a CU is split, another 4 bits may be used to represent if each smaller CU is also split, and so-on. The split process creates a quad-tree that may efficiently describe the structure of a LCU. The VME may decide which and how many splits are performed to reduce or minimize the bits to compress the current LCU.

In some embodiments, each CU may be coded as inter, intra or skip, which may be referred to as the PU. Each PU may also contain a PU split. The PU split options may be different for each PU type. For example, the skip type may have no split options, while the intra type may have 2 split options including 2N×2N or N×N, where N corresponds to a nominal block size (e.g., 2, 4, 8, etc.). The 2N×2N case may have only one prediction mode where the N×N case may have four prediction modes for each N×N block. The inter type may have many more options. For example, eight options may include 2N×2N, 2N×N, N×2N, N×N, 2N×nD, 2N×nU, nL×2N, and nR×2N, where U corresponds to an up portion and D corresponds to a down portion for blocks that are non-square in nature. The last four options may correspond to 4:1 aspect ratio shapes (e.g., where n is half of N).

The number of legal combinations of CU and PU may exceed a million combinations. Including the prediction modes within each PU and all legal motion vector candidates for inter MB's further increases the complexity. A programmable TU decision may also increase the complexity for some tree-based standards. For HEVC, for example, 32×32, 16×16, 8×8 and 4×4 may all be candidate TU options. The TU decisions may be independent from PU choices, but cannot exceed the size of the CU in which they reside. The VME may need to make the right CU and TU choice collectively. Advantageously, some embodiments of modular motion estimator may provide a fast and intelligent VME to make the needed decisions in a correct and timely manner.

In some embodiments, partitioning logic may decide the best subdivision from larger coding elements into smaller ones, taking into account the overhead associated with additional syntax in the bitstream to describe these smaller coding elements. Some tree-based video formats may be too complex to handle the partitioning decision inside the IME message. Some embodiments of a HEVC-based VME may include a partition message called HPM which indicates the CU, PU and TU decision responsibility. The HPM may be indicate such responsibility for these decisions only up to a specified CU level (e.g., up to a 32×32 CU level). In some embodiments, if necessary, 64×64 CU and PU decisions may be the responsibility of the kernel (e.g., where there may be only a handful of legal candidate options to consider).

The inputs to the HPM may be stream-in data from the IME containing a number (e.g., 49) of unique inter shapes for all of the CUs and PUs supported by the IME along with the stream-in data from a number (e.g., 21) of unique intra shapes supported by the SIC. An additional number (e.g., 49) of inter shapes may be input in the case of bi-directional partitioning. The outputs of the HPM may include multiple partitioning candidates which are described by respective CU and PU types and splits.

In some embodiments, the TU decision may not be made inside the HPM because of performance and complexity surrounding the decision. For example, the HPM may instead provide multiple candidates, where each candidate is optimized for different potential maximum TU sizes. The kernel may then inspect the TU-based candidates and identify if one is clearly best or if further analysis is required to make the TU decision. If further analysis is required, a check and refine motion estimation (CRE) engine may support a forward transform (e.g., a HEVC compliant forward transform) up to 32×32 which may be used to compare different CU and PU combinations given different TU candidates. The best TU candidate may then be selected based on the comparison.

SIC Examples

The reference window and/or source size for the SIC may be increased similar to as discussed above for the IME. In some embodiments, HEVC-based predicted motion vector (PMV) calculations may be performed by the VME. Having the PMV calculations performed by the VME may improve cost center generation during the HPM message processing, may compare all the merge mode candidate predictors versus the motion vectors (MVs) similar to the bitstream packer behavior to improve mode decision, and/or may reduce complexity for 16×16 and 8×8 skip replacements. Other VME systems may have to process skip replacements in the kernel because of a dependency on the MV calculation post skip replacement for the previous block.

For example, when the SIC is called, no (0) predictors may be sent to the SOC and the CRE may calculate all the necessary MVs and fetch the data accordingly. All the predictors may be returned back to the kernel for future IME cost calculations. Later, the HPM may regenerate the predictors during partitioning to optimize the mode decision (e.g., after subtracting the MV cost added previously by the IME from the pseudo cost centers used during search). For example, HEVC may have defined a number (e.g., 35) different predictors and the HEVC-based VME may support all of them. All of the predictors may be available to every different CU size in some embodiments. In some embodiments, to minimize the change to an HEVC-based VME while still obtaining a coding gain for HEVC over non-HEVC encoder, the width of the data path for the HEVC-based VME may remain 9 but 35 different interpolation configurations may be supported.

FME Examples

The reference window and/or source size for the FME may be increased similar to as discussed above for the IME. In some embodiments, an HEVC-based VME may process Hpel and Qpel decisions in a greedy fashion in the same call, first identifying the best Hpel result followed by the 8 Qpel locations around that Hpel result for all CU and PU candidates. The FME may support fractional search for 64×64 PUs without increasing the source size to 64×64. For example, the FME may call a fractional/bi-directional prediction (FBR) module four (4) times for each 32×32 block of the 64×64 window and return the eight (8) Hpel distortions for each one in 3×3 distortion mesh. The kernel may then add the 3×3 meshes and identify the best Hpel candidate (e.g., or an integer candidate). The kernel may then call the FBR again four (4) times to generate four (4) 3×3 Qpel meshes. The kernel may then add the 3×3 Qpel meshes and identify the best Qpel candidate (e.g., or a center candidate). For example, the FME mesh may only be an option for a PU of 32×32 and may perform only Hpel or Qpel.

SRM Examples

A skip replacement message may be utilized when a given CU tree is refined but not yet considered for skip/merge candidate replacements. For example, the SRM may identify potential skip replacements which may result in better compression. Some embodiments may utilize the SRM when the skip analysis cannot be performed in-loop with the other rate distortion optimization (RDO) decisions and the skip analysis may be checked as a final step rather than in sequence with other decision stages.

RPM Examples

A residual prediction message may produce the residual error between the source and a given predicted block (e.g., either by inter or intra prediction). The residual error may then be analyzed (e.g., by a SW kernel) for RDO following a forward transform and quantization operation. The residual may also be analyzed for subjective quality enhancement for different transform unit coding options.

Other Examples

Turning now to FIGS. 7A and 7B, an embodiment of a hybrid process flow 95 between a software (SW) component 96 (e.g., a motion estimation kernel) and a hardware (HW) component 97 (e.g., motion estimation circuitry) may include an example control flow from the SW component 96 to exchange evolved messages with the HW component 97 to provide advanced quality and performance. The example control flow of the SW component 96 may include a loop for a given largest coding unit (LCU) which may work either tops-down or bottoms-up to subdivide the coding unit into improved or optimal coding structures. FIG. 7A may show a fine-grained process flow (e.g., where SW sends an atomic message to call each block individually), while FIG. 7B shows a coarse-grained process flow (e.g., where SW sends a compound message to call multiple blocks without further SW intervention). The SW component 96 may first consider the skip/merge prediction type at block 96 a by calling the VME skip+RDE message to provide a CU packet to the skip+RDE module 97 a, which may return the best merge candidate CU along with the associated RDO cost and reconstructed edge pixels. Based on that result, the SW component 96 may then consider integer motion estimation at block 96 b via an IME call to provide another CU packet to the IME module 97 b, which may return a large number of shapes with optimal motion vectors to the SW component 96. The SW component 96 may then consider refinement of inter CU at block 96 c via an inter+RDE message to provide another CU packet to the inter+RDE module 97 c. The inter+RDE module 97 c may refine the CUs by performing fractional motion estimation and/or bidirectional motion estimation with the refined motion vector and may return the best CU candidates along with the associated RDO to the SW component 96. Based on that result, the SW component 96 may perform an RDO comparison with the best identified merge candidate CU. The SW component 96 may also consider a search for intra CU at block 96 d via an intra+RDE message to provide another CU packet to the intra+RDE module 97 d. The intra+RDE module 97 d may perform an intra angular prediction analysis which may consume the reconstructed edge pixels of all neighbors and return an intra candidate CU for the best identified intra angle (e.g., or DC, planar, etc.) along with the RDO cost of the winner to the SW component 96.

Some embodiments may provide one set of RD costs per merge candidate (e.g., as opposed to one set of skip and merge mode costs for all 4 merge candidates). For example, all additional costs may be programmed as a part of the rate distortion estimation (RDE) cost message. Providing one set of RD costs per merge candidate may advantageously provide the encoder flexibility to tune the content for different resolutions with different cost configurations to get better compression (e.g., an average compression gain of 4% in high quantization parameter (QP) cases for class AB/E).

Some or all of these messages may also perform a transform unit (TU) size analysis and return that information in the candidate CU record. Based on the RDO comparison with the best inter, intra and skip, the SW component 96 may identify the best prediction unit (PU) and TU at that CU level. The SW component 96 may then step up or step down a CU level and produce the best combination of CU that may be grouped together to compete with a single CU of a larger size, up to that of the LCU.

In some embodiments, the inter+RDE and skip+RDE messages may utilize up to the full tap width filter interpolation (e.g., 8-tap or as specified for a given video standard) or any smaller filter tap width to save gate count. All message types may be performed as luma channel only, chroma channel only, or both luma and chroma channel distortions combined (e.g., with or without a weighting). In some embodiments, all computations may be performed up to the full bit-depth of each channel or a reduced bit-depth.

In some embodiments, the input surface formats for both source and reference pictures may have their UV planes interleaved. The CRE may process the U pixels followed by the V pixels when accumulating the distortions. For example, the chroma may require two passes in the RDE pipeline. The chroma RDE may be performed for all the TU depths that are supported for the luma RDE. For example, the TU decision may be made with luma+chroma RD distortions when the chroma RDE check is enabled. Additional chroma reconstructed neighbor pixels may be output from the CRE back to the encoder similar to how the luma reconstructed pixels are generated.

In some embodiments, the SW component 96 may provide a CU packet to the HW component 97. In general, the CU packet may contain information which is useful or necessary for the HW component 97 to perform the requested processing. The CU packet may include technology and/or a structure for communication between a motion estimation kernel and motion estimation circuity which is consistent with a bitstream packer and may completely describe a given coding block's syntax elements.

For example, the CU packet may contain a superset of PU and TU information that a given CU may contain. The CU packet may contain the CU size (e.g., 8×8 thru 64×64), up to two motion vector (MV) pairs for two bidirectional PUs along with their reference IDs, PU shapes, TU split depth, luma and chroma intra prediction angles, and the quantization parameter (QP) to be used in the forward and inverse quantization step of RDE processing. A CU packet may be provided to the VME and the VME may optimize the provided information to improve the coding efficiency, returning the improved CU packet back to the control logic (e.g., the kernel). The RDO cost may also be provided back to the control logic for a final mode decision. The selected best CU packet for a given pixel region may eventually be sent to the bitstream packer to produce the final bitstream. In some embodiments, the CU packet may be implemented with a 256 byte packet including fields for one or more of a CU QP (quantization parameter for RDE), a CU Skip Flag (skip, not skip), MV0 and MV1 direction (forward, backward, or bidirectional), CU prediction mode (inter, intra), CU partition Mode (8 of them . . . 2N×2N, 2N×N, N×2N, N×N . . . ), chroma intra mode, CU Size (8×8, 16×16, 32×32, 64×64), luma intra Mode (35 different angles, etc.), CU offset within an LCU, TU split depth, MV0 and MV1 reference ID, and motion vector list 0 (e.g., L0 MV0 and MV1) and motion vector list 1 (e.g., L1 MV0 and MV1).

Some embodiments may differ from a six message type case where SRM, HPM and RPM are no longer utilized. In the process flow 95, for example, rate distortion optimization (RDO) which may previously have been handled by RPM and EU processing may instead be performed by the HW component 97 based on the core message type (e.g., inter, intra, skip, etc.), which may be considered a combination message. With appropriate setup of the SW component 96, neither SRM nor HPM may be necessary. The RDO mode decision may be made from a bottoms-up flow, selecting the best PU and TU for each CU along the way, considering skip/merges. In the process flow 95, for example, HPM may be redundant because the partitioning may also be handled during the bottoms-up flow by comparing the best sub-partition versus the current partition level. Advantageously, the four message types skip+RDE, IME, inter+RDE, and intra+RDE may provide fundamental building block technology for most motion estimation applications (e.g., as a subset of the 10 message types indicated in FIG. 8). The three combination message types (skip+RDE, inter+RDE, intra+RDE), the IME message types, and the other six message types are all useful for different applications. Depending on the application, not all of the message types shown may be available in the VME and/or some message types may be implemented in a dedicated hardware module while others may be implemented in a RPM style and may rely on a graphics processor unit (GPU) or digital signal processor (DSP) to perform the RDO analysis based on the RPM output.

With reference to FIG. 7B, an example of a coarse-grained process flow includes similar operations as described above with reference to FIG. 7A, except that the SW component 96 sends a CU packet as a compound message to call multiple blocks in the HW component 97 without further intervention by the SW component 96. For best candidate CU selection, a multitude of operations are often required to be performed to compare candidate CUs to select the most optimal, where those candidates often require the same pre-requisite information about the surrounding neighbor blocks to be analyzed. As a result, those operations can be grouped together in such a way as to re-use the common pre-requisite information and reduce the communication overhead between the ENC and VME as well as the VME and external memory. These penalties are more significant with the leaf nodes as the compute work reduces with smaller CU sizes while the overhead remains a constant. Accordingly, by including the requested CU level and the next level smaller CU group, these operations can be interleaved and pipelined to more efficiently utilize the underlying compute resources (e.g., especially where four 8×8 CU may be combined together for processing by the 16×16 CU resources).

Some embodiments advantageously provide hybrid atomic and compound block motion estimation and mode decision technology. For many applications, VME with fine-grained MME provides good performance and quality. However, improvements to the VME related to RDE hardware acceleration may under utilize the VME engine (e.g., more flexibility with software kernels may lead to larger kernel sizes and more time preparing messages and less time executing in the VME engine). Embodiments of the hybrid technology described herein may provide additionally flexibility for fine-grained MME where needed while adding the capability for coarse-grained MME for further performance and quality improvements. Advantageously, the coarse-grained MME may reduce kernel size and increase the VME engine utilization. For example, the compound message described herein supports coarse-grained MME where multiple RDE calls originate from a single message. The compound message reduces the number of branches and early exits which would otherwise need to be handled in a software kernel (e.g., see the software process flow for FIG. 7A as compared to FIG. 7B). In some embodiments, the kernel may be significantly shrunk also reducing the amount of graphics register file (GRF) needed to store intermediate results and reconstructed pixels. In some embodiments, an API may be provided which indicate the granularity with which the motion estimation and/or mode decision engine may be called (e.g., supporting an atomic/single block message and a compound/multiple block message). The API may define the input and output interfaces and may provide for a call which returns on a per CU basis to check and return the RD distortion for a combination of inter/intra/fractional/etc. blocks.

To encode or compress a video frame, many decisions may made by the encoder. For example, a block may be spatially predicted (an intra block) or it may be temporally predicted (an inter block). For inter blocks, the motion vector may be derived by the neighbors (a merge block) or it may be a new motion vector (inter block). The size of the block might be 32×32 pixels or 8×8 pixels. The block can even be subdivided into rectangular shapes (such as 32×16). In addition to the above, there are different transform sizes, frequency based decisions such as zero coefficients vs coefficients, etc. To exhaustively check all possible decisions is not feasible for any encoder operating under typical performance constraints. Accordingly, most encoders make tradeoffs between the features supported for the sake of performance while minimizing the impact to quality.

In an example of fine-grained MME, an encoder may start with a 32×32 shape and check merge. If merge is good enough, the encoder could end or the encoder could check 32×32 inter and/or intra candidates. For a fine-grained process flow, there are many stages and many different paths the encoder can follow. All of the different paths are branches in the code which slows the kernel down as the kernel needs to jump between different portions of code and fetch the new instructions from the instruction cache. Additionally, each call has a message that needs to be prepared to call the VME. For shorter calls like the 8×8 intra for instance, the hardware can complete within some number of clocks. But the time it takes to prepare the message for each call will take much longer than the number of clocks the hardware needs to complete, which is part of the inefficiency. Also contributing to the inefficiency is that each 8×8 depends on the decision from the prior 8×8. To ignore the dependencies would give a suboptimal result and lead to inadequate quality. Part of the dependency is knowing the motion vector and mode of the adjacent blocks as well as the reconstructed pixels that are adjacent to the neighbor blocks. Due to these dependencies, the performance impact of checking 8×8 is high and leads to idle VME cycles.

Turning now to FIG. 8, an embodiment of a coarse-grained process flow 200 may utilize a compound message to reduce kernel size and improve VME (HW) utilization. The encoder (SW) may prepare multiple IME calls at block 201 and the VME may call the IME at block 202. If more IME calls need to be made at block 203, the flow 200 may loop back to block 201. Otherwise, the flow 200 may proceed to a 32×32 CU check at block 204, where the encoder may prepare a compound message to process multiple 32×32 blocks (e.g., skip, intra, and inter blocks). At block 205, the VME receives the compound message and calls RDE-CRE for skip/intra/inter blocks. The process flow 200 then determines if the CU should be split at block 206. If not, the flow 200 is done. If so, the flow 200 proceeds to a 16×16 CU check at block 207, where the encoder may prepare a compound message to process multiple 16×16 blocks. At block 208, the VME receives the compound message and calls RDE-CRE for skip/intra/inter blocks. The process flow 200 then determines if the CU should be split again at block 209. If so, the flow 200 may loop proceed to a quad 8×8 CU check at block 210 (e.g., with an indicator that the next RDE-CRE call will be for a quad 8×8 CU check instead of the 16×16 CU check). From block 210, the flow 200 may proceed to block 208, where the VME may utilize the same motion estimation circuitry (HW) for the 8×8 RDE-CRE calls and the 16×16 RDE-CRE calls, but with a specialized call to indicate the quad 8×8 CU check. In other embodiments, the selection of layers to combine in a compound message may span more than two levels (e.g., 32×32 CU, 16×16 CU, and 8×8 CU). When there is no further CU split at block 209, the flow 200 next determines if the quad 16×16 CU checks are is done at block 211. If not, the flow 200 loops back to block 207. If so, the flow 200 proceeds to the final mode decision for the 32×32 CU at block 212 and then the flow 200 is done. Although the process flow 200 is described in connection with a 32×32 CU example, those skilled in the art will appreciate that other embodiments of similar process flows may be generalized to N×N CUs (e.g., with corresponding loops for N/2×N/2, N/4×N/4, and so on). Advantageously, some embodiments may compound different types of CUs, and/or compound different types of CUs with multiple CUs of a CU split (e.g., multiple nodes and/or multiple leaves of a tree structure).

Advantageously, some embodiments of SW/HW to prepare and handle a compound message may address various performance issues for an encoder. For example, the compound message simplifies the flow which reduces the branches and shrinks the size of the kernel. To check a 16×16, for example, the three types of intra, merge, and inter will be called to get the final RDE distortion. Without the compound message, separate messages would need to be prepared individually for each of the three types with all of the parameters needing to be filled out for each call. The prior message could be copied and then modified, but having three separate messages still consumes more GRF space and adjusting the relevant fields for each call requires a significant number of kernel cycles. In the compound message, the message is now a single call for the HW to check the RDE distortion of intra, inter, and merge and there is no need to have all three messages. Advantageously, the simplification of the flow also significantly reduces the instruction size (e.g., by about 50% in some cases). When the compound message is called, the three stages may be pipelined in such a way that the three stages run in parallel and optimize the calls for the different parts of the VME hardware to be more efficient.

Advantageously, some embodiments eliminate the dedicated 8×8 loop, which may have relatively worse performance due to the short nature of the calls. Each 8×8 is instead pipelined with each 8×8 checking the merge, intra, and inter candidates. So 8×8 0 is checked, followed by 8×8 1, etc. Each source block fetch may be pipelined in such a way to be optimized for performance. Advantageously, the reconstructed pixels for each block is stored within the VME (HW) so there isn't a need to store and return the pixels through the message. While the overall performance is improved by about 80%, the 8×8 loop itself is faster by more than 10×.

In some embodiments, a CRE module may be pipelined such that if Skip-RDE message is being computed in the RDE, Intra search can run concurrently with that and similarly if the last Intra-TU is being computed in the RDE, the inter search can run in parallel along with that. In general, the pipeline may be configured to support the compound message and guarantee sequencing of the Merge, Intra and Inter checks for every CU in CRE. The HW may further include additional configurable buffers that may be read/written back and forth to store the reconstructed pixels and support the pipelined operation. In addition, pipelining of a multiple leaf-node CU such as the 8×8 level requires necessary storage buffers to perform optimally.

FIG. 9 illustrates an embodiment of a system 700. In embodiments, system 700 may be a media system although system 700 is not limited to this context. For example, system 700 may be incorporated into a personal computer (PC), laptop computer, ultra-laptop computer, tablet, touch pad, portable computer, handheld computer, palmtop computer, personal digital assistant (PDA), cellular telephone, combination cellular telephone/PDA, television, smart device (e.g., smart phone, smart tablet or smart television), mobile internet device (MID), messaging device, data communication device, and so forth.

In embodiments, the system 700 comprises a platform 702 coupled to a display 720 that presents visual content. The platform 702 may receive video bitstream content from a content device such as content services device(s) 730 or content delivery device(s) 740 or other similar content sources. A navigation controller 750 comprising one or more navigation features may be used to interact with, for example, platform 702 and/or display 720. Each of these components is described in more detail below.

In embodiments, the platform 702 may comprise any combination of a chipset 705, processor 710, memory 712, storage 714, graphics subsystem 715, applications 716 and/or radio 718 (e.g., network controller). The chipset 705 may provide intercommunication among the processor 710, memory 712, storage 714, graphics subsystem 715, applications 716 and/or radio 718. For example, the chipset 705 may include a storage adapter (not depicted) capable of providing intercommunication with the storage 714.

The processor 710 may be implemented as Complex Instruction Set Computer (CISC) or Reduced Instruction Set Computer (RISC) processors, x86 instruction set compatible processors, multi-core, or any other microprocessor or central processing unit (CPU). In embodiments, the processor 710 may comprise dual-core processor(s), dual-core mobile processor(s), and so forth.

The memory 712 may be implemented as a volatile memory device such as, but not limited to, a Random Access Memory (RAM), Dynamic Random Access Memory (DRAM), or Static RAM (SRAM).

The storage 714 may be implemented as a non-volatile storage device such as, but not limited to, a magnetic disk drive, optical disk drive, tape drive, an internal storage device, an attached storage device, flash memory, battery backed-up SDRAM (synchronous DRAM), and/or a network accessible storage device. In embodiments, storage 714 may comprise technology to increase the storage performance enhanced protection for valuable digital media when multiple hard drives are included, for example.

The graphics subsystem 715 may perform processing of images such as still or video for display. The graphics subsystem 715 may be a graphics processing unit (GPU) or a visual processing unit (VPU), for example. An analog or digital interface may be used to communicatively couple the graphics subsystem 715 and display 720. For example, the interface may be any of a High-Definition Multimedia Interface (HDMI), DisplayPort, wireless HDMI, and/or wireless HD compliant techniques. The graphics subsystem 715 could be integrated into processor 710 or chipset 705. The graphics subsystem 715 could be a stand-alone card communicatively coupled to the chipset 705. In one example, the graphics subsystem 715 includes a noise reduction subsystem as described herein.

The graphics and/or video processing techniques described herein may be implemented in various hardware architectures. For example, graphics and/or video functionality may be integrated within a chipset. Alternatively, a discrete graphics and/or video processor may be used. As still another embodiment, the graphics and/or video functions may be implemented by a general purpose processor, including a multi-core processor. In a further embodiment, the functions may be implemented in a consumer electronics device.

The radio 718 may be a network controller including one or more radios capable of transmitting and receiving signals using various suitable wireless communications techniques. Such techniques may involve communications across one or more wireless networks. Exemplary wireless networks include (but are not limited to) wireless local area networks (WLANs), wireless personal area networks (WPANs), wireless metropolitan area network (WMANs), cellular networks, and satellite networks. In communicating across such networks, radio 718 may operate in accordance with one or more applicable standards in any version.

In embodiments, the display 720 may comprise any television type monitor or display. The display 720 may comprise, for example, a computer display screen, touch screen display, video monitor, television-like device, and/or a television. The display 720 may be digital and/or analog. In embodiments, the display 720 may be a holographic display. Also, the display 720 may be a transparent surface that may receive a visual projection. Such projections may convey various forms of information, images, and/or objects. For example, such projections may be a visual overlay for a mobile augmented reality (MAR) application. Under the control of one or more software applications 716, the platform 702 may display user interface 722 on the display 720.

In embodiments, content services device(s) 730 may be hosted by any national, international and/or independent service and thus accessible to the platform 702 via the Internet, for example. The content services device(s) 730 may be coupled to the platform 702 and/or to the display 720. The platform 702 and/or content services device(s) 730 may be coupled to a network 760 to communicate (e.g., send and/or receive) media information to and from network 760. The content delivery device(s) 740 also may be coupled to the platform 702 and/or to the display 720.

In embodiments, the content services device(s) 730 may comprise a cable television box, personal computer, network, telephone, Internet enabled devices or appliance capable of delivering digital information and/or content, and any other similar device capable of unidirectionally or bidirectionally communicating content between content providers and platform 702 and/display 720, via network 760 or directly. It will be appreciated that the content may be communicated unidirectionally and/or bidirectionally to and from any one of the components in system 700 and a content provider via network 760. Examples of content may include any media information including, for example, video, music, medical and gaming information, and so forth.

The content services device(s) 730 receives content such as cable television programming including media information, digital information, and/or other content. Examples of content providers may include any cable or satellite television or radio or Internet content providers. The provided examples are not meant to limit embodiments.

In embodiments, the platform 702 may receive control signals from a navigation controller 750 having one or more navigation features. The navigation features of the controller 750 may be used to interact with the user interface 722, for example. In embodiments, the navigation controller 750 may be a pointing device that may be a computer hardware component (specifically human interface device) that allows a user to input spatial (e.g., continuous and multi-dimensional) data into a computer. Many systems such as graphical user interfaces (GUI), and televisions and monitors allow the user to control and provide data to the computer or television using physical gestures.

Movements of the navigation features of the controller 750 may be echoed on a display (e.g., display 720) by movements of a pointer, cursor, focus ring, or other visual indicators displayed on the display. For example, under the control of software applications 716, the navigation features located on the navigation controller 750 may be mapped to virtual navigation features displayed on the user interface 722, for example. In embodiments, the controller 750 may not be a separate component but integrated into the platform 702 and/or the display 720. Embodiments, however, are not limited to the elements or in the context shown or described herein.

In embodiments, drivers (not shown) may comprise technology to enable users to instantly turn on and off the platform 702 like a television with the touch of a button after initial boot-up, when enabled, for example. Program logic may allow the platform 702 to stream content to media adaptors or other content services device(s) 730 or content delivery device(s) 740 when the platform is turned “off.” In addition, chipset 705 may comprise hardware and/or software support for 5.1 surround sound audio and/or high definition 7.1 surround sound audio, for example. Drivers may include a graphics driver for integrated graphics platforms. In embodiments, the graphics driver may comprise a peripheral component interconnect (PCI) Express graphics card.

In various embodiments, any one or more of the components shown in the system 700 may be integrated. For example, the platform 702 and the content services device(s) 730 may be integrated, or the platform 702 and the content delivery device(s) 740 may be integrated, or the platform 702, the content services device(s) 730, and the content delivery device(s) 740 may be integrated, for example. In various embodiments, the platform 702 and the display 720 may be an integrated unit. The display 720 and content service device(s) 730 may be integrated, or the display 720 and the content delivery device(s) 740 may be integrated, for example. These examples are not meant to limit the embodiments.

In various embodiments, system 700 may be implemented as a wireless system, a wired system, or a combination of both. When implemented as a wireless system, system 700 may include components and interfaces suitable for communicating over a wireless shared media, such as one or more antennas, transmitters, receivers, transceivers, amplifiers, filters, control logic, and so forth. An example of wireless shared media may include portions of a wireless spectrum, such as the RF spectrum and so forth. When implemented as a wired system, system 700 may include components and interfaces suitable for communicating over wired communications media, such as input/output (I/O) adapters, physical connectors to connect the I/O adapter with a corresponding wired communications medium, a network interface card (NIC), disc controller, video controller, audio controller, and so forth. Examples of wired communications media may include a wire, cable, metal leads, printed circuit board (PCB), backplane, switch fabric, semiconductor material, twisted-pair wire, co-axial cable, fiber optics, and so forth.

The platform 702 may establish one or more logical or physical channels to communicate information. The information may include media information and control information. Media information may refer to any data representing content meant for a user. Examples of content may include, for example, data from a voice conversation, videoconference, streaming video, electronic mail (“email”) message, voice mail message, alphanumeric symbols, graphics, image, video, text and so forth. Data from a voice conversation may be, for example, speech information, silence periods, background noise, comfort noise, tones and so forth. Control information may refer to any data representing commands, instructions or control words meant for an automated system. For example, control information may be used to route media information through a system, or instruct a node to process the media information in a predetermined manner. The embodiments, however, are not limited to the elements or in the context shown or described in FIG. 9.

As described above, the system 700 may be embodied in varying physical styles or form factors. FIG. 10 illustrates embodiments of a small form factor device 800 in which the system 700 may be embodied. In embodiments, for example, the device 800 may be implemented as a mobile computing device having wireless capabilities. A mobile computing device may refer to any device having a processing system and a mobile power source or supply, such as one or more batteries, for example.

As described above, examples of a mobile computing device may include a personal computer (PC), laptop computer, ultra-laptop computer, tablet, touch pad, portable computer, handheld computer, palmtop computer, personal digital assistant (PDA), cellular telephone, combination cellular telephone/PDA, television, smart device (e.g., smart phone, smart tablet or smart television), mobile internet device (MID), messaging device, data communication device, and so forth.

Examples of a mobile computing device also may include computers that are arranged to be worn by a person, such as a wrist computer, finger computer, ring computer, eyeglass computer, belt-clip computer, arm-band computer, shoe computers, clothing computers, and other wearable computers. In embodiments, for example, a mobile computing device may be implemented as a smart phone capable of executing computer applications, as well as voice communications and/or data communications. Although some embodiments may be described with a mobile computing device implemented as a smart phone by way of example, it may be appreciated that other embodiments may be implemented using other wireless mobile computing devices as well. The embodiments are not limited in this context.

As shown in FIG. 10, the device 800 may comprise a housing 802, a display 804, an input/output (I/O) device 806, and an antenna 808. The device 800 also may comprise navigation features 812. The display 804 may comprise any suitable display unit for displaying information appropriate for a mobile computing device. The I/O device 806 may comprise any suitable I/O device for entering information into a mobile computing device. Examples for the I/O device 806 may include an alphanumeric keyboard, a numeric keypad, a touch pad, input keys, buttons, switches, rocker switches, microphones, speakers, voice recognition device and software, and so forth. Information also may be entered into the device 800 by way of microphone. Such information may be digitized by a voice recognition device. The embodiments are not limited in this context.

Advantageously, the system 700 and/or the device 800 may include technology to provide one or more aspects of the system 10, the apparatus 20, the system 30, the apparatus 40, the method 50, the modular motion estimator 80, the process flow 95, the process flow 200, or any of the embodiments described herein. For example, the system 700 and/or the device 800 may implement or incorporate features noted in the following examples.

Additional Notes and Examples

Example 1 includes a motion estimation system, comprising a processor, memory communicatively coupled to the processor, and logic communicatively coupled to the processor to receive a compound message, and perform rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message.

Example 2 includes the system of Example 1, wherein the logic is further to perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received compound message.

Example 3 includes the system of any of Examples 1 to 2, wherein the logic is further to perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.

Example 4 includes the system of Example 3, wherein the logic is further to store intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed.

Example 5 includes the system of any of Examples 1 to 4, wherein the logic is further to perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.

Example 6 includes the system of any of Examples 1 to 5, wherein the logic is further to receive an atomic message, and perform rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.

Example 7 includes a motion estimation apparatus for use with a video encoder, comprising one or more substrates, and logic coupled to the one or more substrates, wherein the logic is at least partly implemented in one or more of configurable logic and fixed-functionality hardware logic, the logic coupled to the one or more substrates to receive a compound message, and perform rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message.

Example 8 includes the apparatus of Example 7, wherein the logic is further to perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received compound message.

Example 9 includes the apparatus of any of Examples 7 to 8, wherein the logic is further to perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.

Example 10 includes the apparatus of Example 9, wherein the logic is further to store intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed.

Example 11 includes the apparatus of any of Examples 7 to 10, wherein the logic is further to perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.

Example 12 includes the apparatus of any of Examples 7 to 11, wherein the logic is further to receive an atomic message, and perform rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.

Example 13 includes the apparatus of any of Examples 7 to 12, wherein the logic coupled to the one or more substrates includes transistor channel regions that are positioned within the one or more substrates.

Example 14 includes a method of estimating motion, comprising receiving a compound message, and performing rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message.

Example 15 includes the method of Example 14, further comprising performing rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received compound message.

Example 16 includes the method of any of Examples 14 to 15, further comprising performing rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.

Example 17 includes the method of Example 16, further comprising storing intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed.

Example 18 includes the method of any of Examples 14 to 17, further comprising performing rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.

Example 19 includes the method of any of Examples 14 to 18, further comprising receiving an atomic message, and performing rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.

Example 20 includes at least one computer readable storage medium, comprising a set of instructions, which when executed by a computing device, cause the computing device to receive a compound message, and perform rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message.

Example 21 includes the at least one computer readable storage medium of Example 20, comprising a further set of instructions, which when executed by the computing device, cause the computing device to perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received compound message.

Example 22 includes the at least one computer readable storage medium of any of Examples 20 to 21, comprising a further set of instructions, which when executed by the computing device, cause the computing device to perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.

Example 23 includes the at least one computer readable storage medium of Example 22, comprising a further set of instructions, which when executed by the computing device, cause the computing device to store intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed.

Example 24 includes the at least one computer readable storage medium of any of Examples 20 to 23, comprising a further set of instructions, which when executed by the computing device, cause the computing device to perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.

Example 25 includes the at least one computer readable storage medium of any of Examples 20 to 24, comprising a further set of instructions, which when executed by the computing device, cause the computing device to receive an atomic message, and perform rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.

Example 26 includes a motion estimator apparatus, comprising means for receiving a compound message, and means for performing rate distortion estimation and check refinement for two or more coding unit descriptions for a source block based on the received compound message.

Example 27 includes the apparatus of Example 26, further comprising means for performing rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received compound message.

Example 28 includes the apparatus of any of Examples 26 to 27, further comprising means for performing rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.

Example 29 includes the apparatus of Example 28, further comprising means for storing intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed.

Example 30 includes the apparatus of any of Examples 26 to 29, further comprising means for performing rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.

Example 31 includes the apparatus of any of Examples 26 to 30, further comprising means for receiving an atomic message, and means for performing rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.

Embodiments are applicable for use with all types of semiconductor integrated circuit (“IC”) chips. Examples of these IC chips include but are not limited to processors, controllers, chipset components, programmable logic arrays (PLAs), memory chips, network chips, systems on chip (SoCs), SSD/NAND controller ASICs, and the like. In addition, in some of the drawings, signal conductor lines are represented with lines. Some may be different, to indicate more constituent signal paths, have a number label, to indicate a number of constituent signal paths, and/or have arrows at one or more ends, to indicate primary information flow direction. This, however, should not be construed in a limiting manner. Rather, such added detail may be used in connection with one or more exemplary embodiments to facilitate easier understanding of a circuit. Any represented signal lines, whether or not having additional information, may actually comprise one or more signals that may travel in multiple directions and may be implemented with any suitable type of signal scheme, e.g., digital or analog lines implemented with differential pairs, optical fiber lines, and/or single-ended lines.

Example sizes/models/values/ranges may have been given, although embodiments are not limited to the same. As manufacturing techniques (e.g., photolithography) mature over time, it is expected that devices of smaller size could be manufactured. In addition, well known power/ground connections to IC chips and other components may or may not be shown within the figures, for simplicity of illustration and discussion, and so as not to obscure certain aspects of the embodiments. Further, arrangements may be shown in block diagram form in order to avoid obscuring embodiments, and also in view of the fact that specifics with respect to implementation of such block diagram arrangements are highly dependent upon the platform within which the embodiment is to be implemented, i.e., such specifics should be well within purview of one skilled in the art. Where specific details (e.g., circuits) are set forth in order to describe example embodiments, it should be apparent to one skilled in the art that embodiments can be practiced without, or with variation of, these specific details. The description is thus to be regarded as illustrative instead of limiting.

The term “coupled” may be used herein to refer to any type of relationship, direct or indirect, between the components in question, and may apply to electrical, mechanical, fluid, optical, electromagnetic, electromechanical or other connections. In addition, the terms “first”, “second”, etc. may be used herein only to facilitate discussion, and carry no particular temporal or chronological significance unless otherwise indicated.

As used in this application and in the claims, a list of items joined by the term “one or more of” may mean any combination of the listed terms. For example, the phrase “one or more of A, B, and C” and the phrase “one or more of A, B, or C” both may mean A; B; C; A and B; A and C; B and C; or A, B and C.

Those skilled in the art will appreciate from the foregoing description that the broad techniques of the embodiments can be implemented in a variety of forms. Therefore, while the embodiments have been described in connection with particular examples thereof, the true scope of the embodiments should not be so limited since other modifications will become apparent to the skilled practitioner upon a study of the drawings, specification, and following claims. 

We claim:
 1. A motion estimation system, comprising: a processor; memory communicatively coupled to the processor; and logic communicatively coupled to the processor to: receive a single coding unit packet as a compound message that includes two or more rate distortion estimation calls in the single coding unit packet, and perform two or more rate distortion estimation and check refinement operations, for two or more coding unit descriptions for a source block, that correspond to the two or more rate distortion estimation calls in the received compound message.
 2. The system of claim 1, wherein the logic is further to: perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received single coding unit packet.
 3. The system of claim 1, wherein the logic is further to: perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.
 4. The system of claim 3, wherein the logic is further to: store intermediate results from a first operation on a first of the two or more coding unit descriptions; and use the stored intermediate results when a second operation for rate distortion estimation and check refinement is performed on a second of the two or more coding unit descriptions.
 5. The system of claim 1, wherein the logic is further to: perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.
 6. A motion estimation apparatus for use with a video encoder, comprising: one or more substrates; and logic coupled to the one or more substrates, wherein the logic is at least partly implemented in one or more of configurable logic and fixed-functionality hardware logic, the logic coupled to the one or more substrates to: receive a single coding unit packet as a compound message that includes two or more rate distortion estimation calls in the single coding unit packet, and perform two or more rate distortion estimation and check refinement operations, for two or more coding unit descriptions for a source block, that correspond to the two or more rate distortion estimation calls in the received compound message.
 7. The apparatus of claim 6, wherein the logic is further to: perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received single coding unit packet.
 8. The apparatus of claim 6, wherein the logic is further to: perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.
 9. The apparatus of claim 8, wherein the logic is further to: store intermediate results from a first operation on a first of the two or more coding unit descriptions; and use the stored intermediate results when a second operation for rate distortion estimation and check refinement is performed on a second of the two or more coding unit descriptions.
 10. The apparatus of claim 6, wherein the logic is further to: perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.
 11. The apparatus of claim 6, wherein the logic is further to: receive an atomic message; and perform rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.
 12. The apparatus of claim 6, wherein the logic is further to: process at least two different types of coding units based on the received single coding unit packet.
 13. A method of estimating motion, comprising: receiving a single coding unit packet as a compound message that includes two or more rate distortion estimation calls in the single coding unit packet; and performing two or more rate distortion estimation and check refinement operations, for two or more coding unit descriptions for a source block, that correspond to the two or more rate distortion estimation calls in the received compound message.
 14. The method of claim 13, further comprising: performing rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received single coding unit packet.
 15. The method of claim 13, further comprising: performing rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.
 16. The method of claim 15, further comprising: storing intermediate results for each of the two or more coding unit descriptions for use while the rate distortion estimation and check refinement is performed, storing intermediate results from a first operation on a first of the two or more coding unit descriptions; and using the stored intermediate results when a second operation for rate distortion estimation and check refinement is performed on a second of the two or more coding unit descriptions.
 17. The method of claim 13, further comprising: performing rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.
 18. The method of claim 13, further comprising: receiving an atomic message; and performing rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message.
 19. At least one non-transitory computer readable storage medium, comprising a set of instructions, which when executed by a computing device, cause the computing device to: receive a single coding unit packet as a compound message that includes two or more rate distortion estimation calls in the single coding unit packet; and perform two or more rate distortion estimation and check refinement operations, for two or more coding unit descriptions for a source block, that correspond to the two or more rate distortion estimation calls in the received compound message.
 20. The at least one non-transitory computer readable storage medium of claim 19, comprising a further set of instructions, which when executed by the computing device, cause the computing device to: perform rate distortion estimation and check refinement for an inter candidate coding unit, a skip/merge candidate coding unit, and an intra candidate coding unit based on the received single coding unit packet.
 21. The at least one non-transitory computer readable storage medium of claim 19, comprising a further set of instructions, which when executed by the computing device, cause the computing device to: perform rate distortion estimation and check refinement for the two or more coding unit descriptions in a pipelined manner.
 22. The at least one non-transitory computer readable storage medium of claim 21, comprising a further set of instructions, which when executed by the computing device, cause the computing device to: store intermediate results from a first operation on a first of the two or more coding unit descriptions; and use the stored intermediate results when a second operation for rate distortion estimation and check refinement is performed on a second of the two or more coding unit descriptions.
 23. The at least one non-transitory computer readable storage medium of claim 19, comprising a further set of instructions, which when executed by the computing device, cause the computing device to: perform rate distortion estimation and check refinement for two or more levels of coding units with a same logic circuit.
 24. The at least one non-transitory computer readable storage medium of claim 19, comprising a further set of instructions, which when executed by the computing device, cause the computing device to: receive an atomic message; and perform rate distortion estimation and check refinement for a single inter candidate coding unit, skip/merge candidate coding unit, or intra candidate coding unit based on the received atomic message. 